/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package InstanciaJogo;

import Biblioteca.VerificaErros;
import DAO.DAOInstanciaJogo;
import DAO.MySQL.DAOInstanciaJogoMySQL;
import InstanciaJogo.FasesJogo.Estatica;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import GUI.Jogo.FrameJogo;
import InstanciaJogo.FasesJogo.Dinamica;
import InstanciaJogo.FasesJogo.InstanciaSubFasePattern;
import java.util.ArrayList;
import javax.swing.ImageIcon;

/**
 * InstanciaJogoSwing
 *
 * Versao 1.0
 *
 * Data Criação 07/08/2013
 *
 * @author Igor
 */
public class InstanciaJogoSwing {

    //Atributos
    private long idJogo;
    private InstanciaSubFasePattern faseEstaticaAvatar;
    private InstanciaSubFasePattern faseEstaticaReal;
    private InstanciaSubFasePattern faseDinamica;
    private long fase;
    private long subFase;
    private Timer timerTransacaoImagem;
    private JLabel labelImagem;
    private JLabel labelStatus;
    private FrameJogo telaInicial;
    private int tempoApresentacaoImagens;
    private int tempoTransicaoImagens;
    private int repetirApresentacaoImagens;
    private boolean apresentaMensagemAcertoErro;
    private long modoJogo;
    private long tempoInicioJogo;
    private ArrayList<Integer> percsAvancarSubFases;

    //DAO
    private DAOInstanciaJogo jogoDAO;

    //Construtor
    public InstanciaJogoSwing(long tipoJogo) {
        this.fase = tipoJogo;
        this.subFase = 1; //Comeca-se sempre em 1, incrementa-se no iniciaFaseSubFase se necessario
        this.jogoDAO = new DAOInstanciaJogoMySQL();
        this.tempoInicioJogo = System.currentTimeMillis();
        this.percsAvancarSubFases = new ArrayList<Integer>();
    }

    public InstanciaJogoSwing(JLabel labelImagem, JLabel labelStatus, FrameJogo telaInicial, long tipoJogo) {
        this(tipoJogo);
        this.labelImagem = labelImagem;
        this.labelStatus = labelStatus;
        this.telaInicial = telaInicial;
    }

    //Getters e Setters
    /**
     * @return the idJogo
     */
    public long getIdJogo() {
        return idJogo;
    }

    /**
     * @param idJogo the idJogo to set
     */
    public void setIdJogo(long idJogo) {
        this.idJogo = idJogo;
    }

    /**
     * @return the faseEstaticaAvatar
     */
    public InstanciaSubFasePattern getFaseEstaticaAvatar() {
        return faseEstaticaAvatar;
    }

    /**
     * @param faseEstatica the faseEstaticaAvatar to set
     */
    public void setFaseEstaticaAvatar(Estatica faseEstaticaAvatar) {
        this.faseEstaticaAvatar = faseEstaticaAvatar;
    }

    /**
     * @return the faseEstaticaReal
     */
    public InstanciaSubFasePattern getFaseEstaticaReal() {
        return faseEstaticaReal;
    }

    /**
     * @param faseEstaticaReal the faseEstaticaReal to set
     */
    public void setFaseEstaticaReal(InstanciaSubFasePattern faseEstaticaReal) {
        this.faseEstaticaReal = faseEstaticaReal;
    }

    /**
     * @return the faseDinamica
     */
    public InstanciaSubFasePattern getFaseDinamica() {
        return faseDinamica;
    }

    /**
     * @param faseDinamica the faseDinamica to set
     */
    public void setFaseDinamica(InstanciaSubFasePattern faseDinamica) {
        this.faseDinamica = faseDinamica;
    }

    /**
     * @return the fase
     */
    public long getFase() {
        return fase;
    }

    /**
     * @param fase the fase to set
     */
    public void setFase(long fase) {
        this.fase = fase;
    }

    /**
     * @return the subFase
     */
    public long getSubFase() {
        return subFase;
    }

    /**
     * @param subFase the subFase to set
     */
    public void setSubFase(long subFase) {
        this.subFase = subFase;
    }

    /**
     * @return the timerTransacaoImagem
     */
    public Timer getTimerTransacaoImagem() {
        return timerTransacaoImagem;
    }

    /**
     * @param timerTransacaoImagem the timerTransacaoImagem to set
     */
    public void setTimerTransacaoImagem(Timer timerTransacaoImagem) {
        this.timerTransacaoImagem = timerTransacaoImagem;
    }

    /**
     * @return the labelImagemApresentadaSubFase
     */
    public JLabel getLabelImagem() {
        return labelImagem;
    }

    /**
     *
     * @param labelImagem
     */
    public void setLabelImagem(JLabel labelImagem) {
        this.labelImagem = labelImagem;
    }

    /**
     * @return the labelStatus
     */
    public JLabel getLabelStatus() {
        return labelStatus;
    }

    /**
     * @param labelStatus the labelStatus to set
     */
    public void setLabelStatus(JLabel labelStatus) {
        this.labelStatus = labelStatus;
    }

    /**
     * @return the telaInicial
     */
    public FrameJogo getTelaInicial() {
        return telaInicial;
    }

    /**
     * @param telaInicial the telaInicial to set
     */
    public void setTelaInicial(FrameJogo telaInicial) {
        this.telaInicial = telaInicial;
    }

    /**
     * @return the tempoApresentacaoImagens
     */
    public int getTempoApresentacaoImagens() {
        return tempoApresentacaoImagens;
    }

    /**
     * @param tempoApresentacaoImagens the tempoApresentacaoImagens to set
     */
    public void setTempoApresentacaoImagens(int tempoApresentacaoImagens) {
        this.tempoApresentacaoImagens = tempoApresentacaoImagens;
    }

    /**
     * @return the tempoTransicaoImagens
     */
    public int getTempoTransicaoImagens() {
        return tempoTransicaoImagens;
    }

    /**
     * @param tempoTransicaoImagens the tempoTransicaoImagens to set
     */
    public void setTempoTransicaoImagens(int tempoTransicaoImagens) {
        this.tempoTransicaoImagens = tempoTransicaoImagens;
    }

    /**
     * @return the repetirApresentacaoImagens
     */
    public int getRepetirApresentacaoImagens() {
        return repetirApresentacaoImagens;
    }

    /**
     * @param repetirApresentacaoImagens the repetirApresentacaoImagens to set
     */
    public void setRepetirApresentacaoImagens(int repetirApresentacaoImagens) {
        this.repetirApresentacaoImagens = repetirApresentacaoImagens;
    }

    /**
     * @return the apresentaMensagemAcertoErro
     */
    public boolean isApresentaMensagemAcertoErro() {
        return apresentaMensagemAcertoErro;
    }

    /**
     * @param apresentaMensagemAcertoErro the apresentaMensagemAcertoErro to set
     */
    public void setApresentaMensagemAcertoErro(boolean apresentaMensagemAcertoErro) {
        this.apresentaMensagemAcertoErro = apresentaMensagemAcertoErro;
    }

    /**
     * @return the jogoDAO
     */
    public DAOInstanciaJogo getJogoDAO() {
        return jogoDAO;
    }

    /**
     * @param jogoDAO the jogoDAO to set
     */
    public void setJogoDAO(DAOInstanciaJogo jogoDAO) {
        this.jogoDAO = jogoDAO;
    }

    /**
     * @return the modoJogo
     */
    public long getModoJogo() {
        return modoJogo;
    }

    /**
     * @param modoJogo the modoJogo to set
     */
    public void setModoJogo(long modoJogo) {
        this.modoJogo = modoJogo;
    }

    /**
     * @return the tempoInicioJogo
     */
    public long getTempoInicioJogo() {
        return tempoInicioJogo;
    }

    /**
     * @param tempoInicioJogo the tempoInicioJogo to set
     */
    public void setTempoInicioJogo(long tempoInicioJogo) {
        this.tempoInicioJogo = tempoInicioJogo;
    }

    /**
     * @return the percsAvancarSubFases
     */
    public ArrayList<Integer> getPercsAvancarSubFases() {
        return percsAvancarSubFases;
    }

    /**
     * @param percsAvancarSubFases the percsAvancarSubFases to set
     */
    public void setPercsAvancarSubFases(ArrayList<Integer> percsAvancarSubFases) {
        this.percsAvancarSubFases = percsAvancarSubFases;
    }

    //Outros metodos
    /**
     * Retorna a quantidade de imagens para avaliar dependendo da Fase que estiver
     * @return 
     */
    public int getQuantidadeImagensParaAvaliar() {
        switch ((int) getFase()) {
            case 1:
                if (getFaseEstaticaAvatar() != null) {
                    return getFaseEstaticaAvatar().getQuantidadeImagensParaAvaliar();
                }
                break;
            case 2:
                if (getFaseDinamica() != null) {
                    return getFaseDinamica().getQuantidadeImagensParaAvaliar();
                }
            case 3:
                if (getFaseEstaticaReal() != null) {
                    return getFaseEstaticaReal().getQuantidadeImagensParaAvaliar();
                }
                break;
        }
        return 0;
    }

    /**
     * Inicia as subFase corretamente
     *
     * @param jogoPausado define se a apresentacao da imagem prove do pause no
     * jogo
     */
    public void iniciaFaseSubFase(boolean jogoPausado) throws Exception {
        long proncentagemAcerto = 0;
        /* Retornos esperados
         0: Abre tela de mudanca de Fase/SubFase
         1: Continua apresentando imagens (pois ainda esta na mesma Fase/SubFase)
         2: Termina o jogo
         */
        switch (gerenciarFasesJogo(jogoPausado)) {

            //Apresenta tela de troca de SubFase
            case 0:
                switch ((int) getFase()) {
                    case 1:
                        if (getFaseEstaticaAvatar() != null) {
                            getFaseEstaticaAvatar().getSubFaseDAO().atualizaTempoSubFase(getFaseEstaticaAvatar().getIdInstanciaSubFase(), System.currentTimeMillis() - getFaseEstaticaAvatar().getTempoInicioSubFase());

                            //Muda a subFase caso tenha ultrapassado o percentual de acerto
                            if (getFaseEstaticaAvatar().buscaPorcentagemAcerto() >= getFaseEstaticaAvatar().getPercAvancarSubFases()
                                    || getModoJogo() == 2
                                    || getModoJogo() == 1) {
                                setSubFase(getSubFase() + 1);
                            }

                            //Muda a fase somente se apresentou/avaliou tds imagens da ultima subFase
                            if (getSubFase() > getFaseEstaticaAvatar().getSubFaseUltima() && getQuantidadeImagensParaAvaliar() <= 0) {
                                setFase(-1);
                                setSubFase(1);
                            }
                        }
                        proncentagemAcerto = getFaseEstaticaAvatar().buscaPorcentagemAcerto();
                        break;
                    case 2:
                        if (getFaseDinamica() != null) {
                            getFaseDinamica().getSubFaseDAO().atualizaTempoSubFase(getFaseDinamica().getIdInstanciaSubFase(), System.currentTimeMillis() - getFaseDinamica().getTempoInicioSubFase());

                            //Muda a subFase caso tenha ultrapassado o percentual de acerto
                            if (getFaseDinamica().buscaPorcentagemAcerto() >= getFaseDinamica().getPercAvancarSubFases()
                                    || getModoJogo() == 2
                                    || getModoJogo() == 1) {
                                setSubFase(getSubFase() + 1);
                            }

                            //Muda a fase somente se apresentou/avaliou tds imagens da ultima subFase
                            if (getSubFase() > getFaseDinamica().getSubFaseUltima() && getQuantidadeImagensParaAvaliar() <= 0) {
                                setFase(-1);
                                setSubFase(1);
                            }
                        }
                        proncentagemAcerto = getFaseDinamica().buscaPorcentagemAcerto();
                        break;
                    case 3:
                        if (getFaseEstaticaReal() != null) {
                            getFaseEstaticaReal().getSubFaseDAO().atualizaTempoSubFase(getFaseEstaticaReal().getIdInstanciaSubFase(), System.currentTimeMillis() - getFaseEstaticaReal().getTempoInicioSubFase());

                            //Muda a subFase caso tenha ultrapassado o percentual de acerto
                            if (getFaseEstaticaReal().buscaPorcentagemAcerto() >= getFaseEstaticaReal().getPercAvancarSubFases()
                                    || getModoJogo() == 2
                                    || getModoJogo() == 1) {
                                setSubFase(getSubFase() + 1);
                            }

                            //Muda a fase somente se apresentou/avaliou tds imagens da ultima subFase
                            if (getSubFase() > getFaseEstaticaReal().getSubFaseUltima() && getQuantidadeImagensParaAvaliar() <= 0) {
                                setFase(-1);
                                setSubFase(1);
                            }
                        }
                        proncentagemAcerto = getFaseEstaticaReal().buscaPorcentagemAcerto();
                        break;
                }
                getTelaInicial().ativarPanelTrocaFaseSubFase(proncentagemAcerto);
                setFaseEstaticaAvatar(null); //Coloco como null pq esta subFase acabou e se iniciara outra nova
                setFaseDinamica(null);
                setFaseEstaticaReal(null);
                break;
            //Jogo continua normalmente
            case 1:
                apresentarImagem(jogoPausado);
                break;
            //Jogo eh finalizado
            default:
                getJogoDAO().atualizaTempoInstanciaJogo(idJogo, System.currentTimeMillis() - getTempoInicioJogo());
                getTelaInicial().ativarPanelFimJogo();
                break;
        }
    }

    /**
     * Faz a apresentacao das imagens, chamando o metodo da classe Estatica ou
     * da Dinamica dependendo da fase em que se encontra
     *
     * @param jogoPausado define se a apresentacao da imagem prove do pause no
     * jogo
     */
    public void apresentarImagem(boolean jogoPausado) {
        try {
            if (getTimerTransacaoImagem() != null) {
                getTimerTransacaoImagem().cancel();
            }

            //Especifica que eh uma imagem de rosto que esta sendo apresentada, pois temos imagens de acerto e erro
            //gambiarra
            labelImagem.setName("imagemRosto");

            switch ((int) getFase()) {
                case 1:
                    if (getSubFase() <= getFaseEstaticaAvatar().getSubFaseUltima()) {
                        getLabelImagem().setIcon(null);
                        getLabelImagem().repaint();

                        //Enquanto existir imagens para avaliar, ira apresentar imagens
                        if (getQuantidadeImagensParaAvaliar() > 0 || jogoPausado) {
                            getFaseEstaticaAvatar().apresentarImagem(this, jogoPausado);
                        } else {
                            iniciaFaseSubFase(false);
                        }
                    }
                    break;
                case 2:
                    if (getSubFase() <= getFaseDinamica().getSubFaseUltima()) {
                        getLabelImagem().setIcon(null);
                        getLabelImagem().repaint();

                        //Enquanto existir imagens para avaliar, ira apresentar imagens
                        if (getQuantidadeImagensParaAvaliar() > 0 || jogoPausado) {
                            getFaseDinamica().apresentarImagem(this, jogoPausado);
                        } else {
                            iniciaFaseSubFase(false);
                        }
                    }
                    break;
                case 3:
                    if (getSubFase() <= getFaseEstaticaReal().getSubFaseUltima()) {
                        getLabelImagem().setIcon(null);
                        getLabelImagem().repaint();

                        //Enquanto existir imagens para avaliar, ira apresentar imagens
                        if (getQuantidadeImagensParaAvaliar() > 0 || jogoPausado) {
                            getFaseEstaticaReal().apresentarImagem(this, jogoPausado);
                        } else {
                            iniciaFaseSubFase(false);
                        }
                    }
                    break;
            }

        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, VerificaErros.retornaMensagemErro(e), "Erro!", JOptionPane.ERROR_MESSAGE);
        }
    }

    /**
     * Gerencia fases Estatica e Dinamica, buscando novas imagens quando
     * necessario (toda vez que mudar de Fase e/ou SubFase)
     *
     * @return Verdadeiro se o jogo nao terminou e False se o jogo terminou
     */
    public int gerenciarFasesJogo(boolean jogoPausado) throws Exception {
        switch ((int) getFase()) {
            //Fase Estatica
            case 1:
                if (getFaseEstaticaAvatar() == null) {

                    setFaseEstaticaAvatar(new Estatica(getSubFase()));
                    getFaseEstaticaAvatar().setIdFase(getFase());
                    getFaseEstaticaAvatar().getImagensDinamicas().setImagensEstaticas((long) (5 - getSubFase()) * 25, repetirApresentacaoImagens, getFase());
                    getFaseEstaticaAvatar().setQuantidadeImagensParaAvaliar();
                    //Especifica o percentual para avancar na subFase
                    getFaseEstaticaAvatar().setPercAvancarSubFases(getPercsAvancarSubFases().get((int) getSubFase() - 1));
                    //Se nao for Treinamento, gravo a instancia da Fase Estatica e retorno o ID
                    if (getModoJogo() != 1) {
                        getFaseEstaticaAvatar().setSubFaseUltima(getFaseEstaticaAvatar().getSubFaseDAO().buscaSubFaseUltima(getFase()));
                        getFaseEstaticaAvatar().setIdInstanciaSubFase(getFaseEstaticaAvatar().gravaInstanciaSubFase(getIdJogo()));
                    } else {
                        //Treinamento so possui a SubFase 1, com apresentacao de 100% das expressoes
                        getFaseEstaticaAvatar().setSubFaseUltima(1);
                        getFaseEstaticaAvatar().setIdInstanciaSubFase(-1);

                    }
                } else {
                    //Se todas imagens ja foram avaliadas
                    if ((getQuantidadeImagensParaAvaliar() <= 0) && (!jogoPausado)) {
                        return 0;
                    }
                }
                break;

            case 2:
                if (getFaseDinamica() == null) {
                    setFaseDinamica(new Dinamica(getSubFase()));
                    getFaseDinamica().getImagensDinamicas().setImagensDinaimacas(repetirApresentacaoImagens, getFase());
                    getFaseDinamica().setQuantidadeImagensParaAvaliar();
                    getFaseDinamica().setSubFaseUltima(getFaseDinamica().getSubFaseDAO().buscaSubFaseUltima(getFase()));
                    //Especifica o percentual para avancar na subFase
                    getFaseDinamica().setPercAvancarSubFases(getPercsAvancarSubFases().get((int) getSubFase() - 1));
                    //Se nao for Treinamento, gravo a instancia da Fase Estatica e retorno o ID
                    if (getModoJogo() != 1) {
                        getFaseDinamica().setIdInstanciaSubFase(getFaseDinamica().gravaInstanciaSubFase(getIdJogo()));
                    } else {
                        getFaseDinamica().setIdInstanciaSubFase(-1);
                    }
                } else {
                    if (getQuantidadeImagensParaAvaliar() <= 0) {
                        return 0;
                    }
                }
                break;
            case 3:
                if (getFaseEstaticaReal() == null) {

                    setFaseEstaticaReal(new Estatica(getSubFase()));
                    getFaseEstaticaReal().setIdFase(getFase());
                    getFaseEstaticaReal().getImagensDinamicas().setImagensEstaticas((long) (5 - getSubFase()) * 25, repetirApresentacaoImagens, getFase());
                    getFaseEstaticaReal().setQuantidadeImagensParaAvaliar();
                    //Especifica o percentual para avancar na subFase
                    getFaseEstaticaReal().setPercAvancarSubFases(getPercsAvancarSubFases().get((int) getSubFase() - 1));
                    //Se nao for Treinamento, gravo a instancia da Fase Estatica e retorno o ID
                    if (getModoJogo() != 1) {
                        getFaseEstaticaReal().setSubFaseUltima(getFaseEstaticaReal().getSubFaseDAO().buscaSubFaseUltima(getFase()));
                        getFaseEstaticaReal().setIdInstanciaSubFase(getFaseEstaticaReal().gravaInstanciaSubFase(getIdJogo()));
                    } else {
                        //Treinamento so possui a SubFase 1, com apresentacao de 100% das expressoes
                        getFaseEstaticaReal().setSubFaseUltima(1);
                        getFaseEstaticaReal().setIdInstanciaSubFase(-1);

                    }
                } else {
                    //Se todas imagens ja foram avaliadas
                    if ((getQuantidadeImagensParaAvaliar() <= 0) && (!jogoPausado)) {
                        return 0;
                    }
                }
                break;
            default:
                //Fim de Jogo
                System.out.println("FIM DE JOGO");
                return 2;
        }
        return 1;

    }

    /**
     * Apresenta uma imagem vazia para representar a transação de imagem
     */
    public void apresentaTransicaoImagens() {
        setTimerTransacaoImagem(new Timer());
        getTimerTransacaoImagem().schedule(new RemindTaskA(getTimerTransacaoImagem(), getTempoTransicaoImagens()), 0, 1 * 1000);
    }

    /**
     * realiza avaliacao da imagem apresentada, verifica se a fase eh estatica
     * ou dinamica para avaliar corretamente
     *
     * @param idExpressaoResposta expressao avaliada pelo jogador
     */
    public void avaliarImagem(int idExpressaoResposta) throws Exception {
        String dirImagem = "./banco_de_dados/imagens_sistema/";
        Boolean avaliacao = false;

        if (getTimerTransacaoImagem() != null) {
            getTimerTransacaoImagem().cancel();
            getTimerTransacaoImagem().purge();
        }

        if (getFaseEstaticaAvatar() != null) {
            if (getFaseEstaticaAvatar().getTimerApresentarImagem() != null) {
                getFaseEstaticaAvatar().stopTimer();
            }
        }

        if (getFaseDinamica() != null) {
            if (getFaseDinamica().getTimerApresentarImagem() != null) {
                getFaseDinamica().stopTimer();
            }
        }

        if (getFaseEstaticaReal() != null) {
            if (getFaseEstaticaReal().getTimerApresentarImagem() != null) {
                getFaseEstaticaReal().stopTimer();
            }
        }

        labelImagem.setIcon(null);
        atualizarLabel(labelImagem);
        switch ((int) getFase()) {
            //Fase Estatica
            case 1:
                avaliacao = getFaseEstaticaAvatar().avaliarExpressaoImagem(idExpressaoResposta, getModoJogo());
                break;
            case 2:
                avaliacao = getFaseDinamica().avaliarExpressaoImagem(idExpressaoResposta, getModoJogo());
                break;
            case 3:
                avaliacao = getFaseEstaticaReal().avaliarExpressaoImagem(idExpressaoResposta, getModoJogo());
                break;
        }

        if (avaliacao) {
            //gambiarra
            dirImagem = dirImagem + "acertou1.png";
            getLabelImagem().setName("acertouAvaliacao");
        } else {
            //gambiarra
            dirImagem = dirImagem + "errou1.png";
            getLabelImagem().setName("errouAvaliacao");
        }

        if (isApresentaMensagemAcertoErro()) {
            ImageIcon ig = new ImageIcon(dirImagem);

            //Amplia a imagem fazendo-a ocupar todo o JLabel
            //.getScaledInstance(getLabelImagem().getWidth(), getLabelImagem().getHeight(), Image.SCALE_DEFAULT)
            getLabelImagem().setIcon(new ImageIcon(ig.getImage()));
            atualizarLabel(labelImagem);
        }
        apresentaTransicaoImagens();
    }

    /**
     * Grava, no Banco de Dados, uma instancia de Jogo
     *
     * @return
     */
    public long gravaInstanciaJogo() throws Exception {
        return getJogoDAO().gravaInstanciaJogo(this, percsAvancarSubFases);
    }

    /**
     * Pausa jogo possibilitando
     */
    public void pausarJogo() {
        try {
            if (getTimerTransacaoImagem() != null) {
                getTimerTransacaoImagem().cancel();
            }

            switch ((int) getFase()) {
                case 1:
                    if (getFaseEstaticaAvatar().getTimerApresentarImagem() != null) {
                        getFaseEstaticaAvatar().stopTimer();
                    }
                    break;
                case 2:
                    if (getFaseDinamica().getTimerApresentarImagem() != null) {
                        getFaseDinamica().stopTimer();
                    }
                    break;
                case 3:
                    if (getFaseEstaticaReal().getTimerApresentarImagem() != null) {
                        getFaseEstaticaReal().stopTimer();
                    }
                    break;
            }

            getLabelImagem().setIcon(null);
            getTelaInicial().ativarPanelJogoPausado();
        } catch (Exception e) {
            JOptionPane.showMessageDialog(null, VerificaErros.retornaMensagemErro(e), "Erro!", JOptionPane.ERROR_MESSAGE);
        }
    }

    public void atualizarLabel(final JLabel labelAtualizar) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                telaInicial.revalidate();
                telaInicial.repaint();
                labelAtualizar.revalidate();
                labelAtualizar.repaint();
            }
        });
    }

    class RemindTaskA extends TimerTask {

        private int segundos;
        private Timer timer = null;

        public RemindTaskA(Timer timer, int tempoEspera) {
            this.segundos = tempoEspera;
            this.timer = timer;
        }

        @Override
        public void run() {
            if (this.segundos == 0) {
                this.timer.cancel();
                timerTransacaoImagem.cancel();
                apresentarImagem(false);
            }
            segundos--;
        }
    }
}
